home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / midi / gfft.lha / gfft-2.03 / source / gfft-2.03-source.lha / saveset.c < prev    next >
C/C++ Source or Header  |  1996-01-02  |  7KB  |  226 lines
  1. /***************************************************************************
  2.  *          Copyright (C) 1994  Charles P. Peterson                  *
  3.  *         4007 Enchanted Sun, San Antonio, Texas 78244-1254             *
  4.  *              Email: Charles_P_Peterson@fcircus.sat.tx.us                *
  5.  *                                                                         *
  6.  *          This is free software with NO WARRANTY.                  *
  7.  *          See gfft.c, or run program itself, for details.              *
  8.  *              Support is available for a fee.                      *
  9.  ***************************************************************************
  10.  *
  11.  * Program:     gfft--General FFT analysis
  12.  * File:        saveset.c
  13.  * Purpose:     save settings
  14.  * Author:      Charles Peterson (CPP)
  15.  * History:     11-Feb-95 CPP (1.39); Created.
  16.  * Comment:     
  17.  */
  18.  
  19. #include <stdio.h>
  20. #include <string.h>
  21.  
  22. #include "gfft.h"
  23. #include "settings.h"
  24.  
  25. #define WRITE_BOOLEAN( NAME, VARIABLE, DEFLT) \
  26.   write_boolean (fp, cstr, NAME, VARIABLE, DEFLT);
  27.  
  28. static void write_boolean (FILE *fp, char *cstr, char *name, 
  29.                BOOLEAN variable, BOOLEAN deflt)
  30. {
  31.     if (variable && !deflt)
  32.     {
  33.     fprintf (fp, "%s%s\n", cstr, name);
  34.     }
  35.     else if (!variable && deflt)
  36.     {
  37.     fprintf (fp, "%sNo%s\n", cstr, name);
  38.     }
  39. }
  40.  
  41. #define WRITE_ULONG( NAME, VARIABLE, DEFLT, IGNORE1) \
  42. write_ulong (fp, cstr, NAME, VARIABLE, DEFLT, IGNORE1)
  43.  
  44. static void write_ulong (FILE *fp, char *cstr, char *name, ULONG variable, 
  45.              ULONG deflt, ULONG ignore1)
  46. {
  47.     if (!(variable == deflt || variable == ignore1))
  48.     {
  49.     fprintf (fp, "%s%s=%lu\n", cstr, name, variable);
  50.     }
  51. }
  52.  
  53. #define WRITE_LONG( NAME, VARIABLE, DEFLT, IGNORE) \
  54. write_long (fp, cstr, NAME, VARIABLE, DEFLT, IGNORE)
  55.  
  56. static void write_long (FILE *fp, char *cstr, char *name, long variable, 
  57.             long deflt, long ignore)
  58. {
  59.     if (!(variable == deflt || variable == ignore))
  60.     {
  61.     fprintf (fp, "%s%s=%ld\n", cstr, name, variable);
  62.     }
  63. }
  64.  
  65. #define WRITE_DOUBLE( NAME, VARIABLE, DEFLT, IGNORE) \
  66. write_double (fp, cstr, NAME, VARIABLE, DEFLT, IGNORE)
  67.  
  68. static void write_double (FILE *fp, char *cstr, char *name, 
  69.               double variable, double deflt, double ignore)
  70. {
  71.     if (!(variable == deflt || variable == ignore))
  72.     {
  73. #ifdef _FFP
  74.     fprintf (fp, "%s%s=%19.12g\n", cstr, name, variable);
  75. #else
  76.     fprintf (fp, "%s%s=%15.8g\n", cstr, name, variable);
  77. #endif
  78.     }
  79. }
  80.  
  81. #define WRITE_CHARS( NAME, VARIABLE) \
  82.   write_chars (fp, cstr, NAME, VARIABLE)
  83.  
  84. static void write_chars (FILE *fp, char *cstr, char *name, char *variable)
  85. {
  86.     if (variable && strlen (variable))
  87.     {
  88.     fprintf (fp, "%s%s=%s\n", cstr, name, variable);
  89.     }
  90. }
  91.  
  92. #define WRITE_WINDOWT( VARIABLE, DEFLT) \
  93.   write_windowt (fp, cstr, VARIABLE, DEFLT);
  94.  
  95. static void write_windowt (FILE *fp, char *cstr, int variable, int deflt)
  96. {
  97.     char *windowt;
  98.  
  99.     if (variable != deflt)
  100.     {
  101.     switch (variable)
  102.     {
  103.     case RECTANGLE_WINDOW:
  104.         windowt = "Rectangle";
  105.         break;
  106.     case TRIANGLE_WINDOW:
  107.         windowt = "Triangle";
  108.         break;
  109.     case PARZEN_WINDOW:
  110.         windowt = "Parzen";
  111.         break;
  112.     case WELCH_WINDOW:
  113.         windowt = "Welch";
  114.         break;
  115.     case HANN_WINDOW:
  116.         windowt = "Hann";
  117.         break;
  118.     case HAMMING_WINDOW:
  119.         windowt = "Hamming";
  120.         break;
  121.     case BLACKMAN_HARRIS_74DB_WINDOW:
  122.         windowt = "74dB-Blackman-Harris";
  123.         break;
  124.     case BLACKMAN_HARRIS_92DB_WINDOW:
  125.         windowt = "92dB-Blackman-Harris";
  126.         break;
  127.     default:
  128.         return;
  129.     }
  130.     fprintf (fp, "%s%s\n", cstr, windowt);
  131.     }
  132. }
  133.  
  134. #define WRITE_CAL_LIST( VARIABLE) \
  135.   calibration_list__write (fp, cstr, &VARIABLE);
  136.  
  137.  
  138. #define WRITE_PLOT_COMMANDS( NAME, VARIABLE) \
  139.   write_plot_commands (fp, cstr, NAME, VARIABLE);
  140.  
  141.  
  142. void write_settings (FILE *fp, char *cstr, BOOLEAN show_read,
  143.              BOOLEAN show_write)
  144. {
  145.     if (show_read)
  146.     {
  147.     WRITE_CHARS ("Read", ReadName);
  148.     }
  149.  
  150.     if (show_write)
  151.     {
  152.     if (Appending)
  153.     {
  154.         WRITE_CHARS ("Append", WriteName);
  155.     }
  156.     else
  157.     {
  158.         WRITE_CHARS ("Write", WriteName);
  159.     }
  160.     }
  161.  
  162. /*  WRITE_BOOLEAN ("Amplitude", Amplitude, TRUE);  
  163.       True by default, else write POWER */
  164.  
  165.     WRITE_CAL_LIST (CalibrationList);
  166.     WRITE_ULONG ("Channel", Channel, 1L, 0L);
  167.     WRITE_BOOLEAN ("CombinePlots", CombinePlots, FALSE);
  168.     WRITE_BOOLEAN ("Db", Db, FALSE);
  169.     WRITE_ULONG ("Frames", Frames, ULONG_MAX, ULONG_MAX);
  170.     WRITE_BOOLEAN ("Header", Header, TRUE)
  171.     WRITE_BOOLEAN ("Hidden3D", Hidden3D, TRUE);
  172.     WRITE_DOUBLE ("HighFrequency", HighFrequency, HIGHEST_FREQUENCY, HIGHEST_FREQUENCY);
  173.     WRITE_DOUBLE ("HighY", HighY, HIGHEST_Y, HIGHEST_Y);
  174.     WRITE_BOOLEAN ("IgnoreFormat", IgnoreFormat, FALSE);
  175. /*    WRITE_PARAMETER (IOFormatS, InputFormat, INPUT_FORMAT_DEFAULTS); */
  176.     WRITE_ULONG ("Interleave", Interleave, 1, INVALID_INTERLEAVE);
  177.     WRITE_BOOLEAN ("LogX", LogX, FALSE);
  178.     WRITE_BOOLEAN ("LogY", LogY, FALSE);
  179.     WRITE_DOUBLE ("LowFrequency", LowFrequency, LOWEST_FREQUENCY, LOWEST_FREQUENCY);
  180.     WRITE_DOUBLE ("LowY", LowY, LOWEST_Y, LOWEST_Y);
  181.     WRITE_ULONG ("Key", Key, 0, 0);
  182.  
  183. /*  WRITE_BOOLEAN ("Mean", Mean, TRUE); true by default, else set SUM */
  184.  
  185.     WRITE_DOUBLE ("Multiply", Multiply, 1.0L, 1.0L);
  186.     WRITE_LONG ("NumberBins", NumberBins, MAX_BINS, INVALID_BINS);
  187.     WRITE_BOOLEAN ("Numerical", Numerical, FALSE);
  188.     WRITE_ULONG ("Octave", Octave, 1L, 1L);
  189.     WRITE_BOOLEAN ("OneShotOnly", OneShotOnly, FALSE);
  190. /*     WRITE_PARAMETER (IOFormatS, OutputFormat, OUTPUT_FORMAT_DEFAULTS); */
  191.     WRITE_BOOLEAN ("Overlap", Overlap, TRUE);
  192.     WRITE_BOOLEAN ("Pad", Pad, FALSE);
  193.     WRITE_BOOLEAN ("Parseval", Parseval, TRUE);
  194.     WRITE_BOOLEAN ("Pink", Pink, FALSE);
  195.     WRITE_BOOLEAN ("Plot", Plot, NO_PLOT);
  196.     WRITE_PLOT_COMMANDS ("PlotCommand", PlotCommands);
  197.     WRITE_CHARS ("PlotOutput", PlotOutput);
  198.     WRITE_BOOLEAN ("Power", Power, FALSE);
  199.     WRITE_BOOLEAN ("PSDensity", PSDensity, FALSE);
  200.     WRITE_DOUBLE ("Quantization", Quantization, MIN_QUANTIZATION, 
  201.           BAD_QUANTIZATION);
  202.     WRITE_BOOLEAN ("Quiet", Quiet, FALSE);
  203.     WRITE_DOUBLE ("Rate", Rate, AUTO_RATE, INVALID_RATE);
  204.     WRITE_DOUBLE ("RotX", RotX, DEF_ROT_X, INVALID_ROTATION);
  205.     WRITE_DOUBLE ("RotZ", RotZ, DEF_ROT_Z, INVALID_ROTATION);
  206.  
  207.     WRITE_BOOLEAN ("RepeatOnly", RepeatOnly, FALSE);
  208.     WRITE_BOOLEAN ("SaveMemory", SaveMemory, FALSE);
  209.     WRITE_LONG ("SmoothingSegments", SmoothingSegments, NO_SMOOTHING, 
  210.         INVALID_SMOOTHING);
  211.     WRITE_BOOLEAN ("SquaredSmoothing", SquaredSmoothing, FALSE);
  212.     WRITE_ULONG ("StartByte", StartByte, 0, 0);
  213.     WRITE_ULONG ("StartFrame", StartFrame, 0, 0);
  214.     WRITE_ULONG ("StopByte", StopByte, ULONG_MAX, ULONG_MAX);
  215.     WRITE_CHARS ("Terminal", Terminal);
  216.     WRITE_BOOLEAN ("Time3D", Time3D, FALSE);
  217.     WRITE_LONG ("TimeOffset", TimeOffset, NOT_SET, INVALID_SET);
  218.     WRITE_DOUBLE ("TimeOverlap", TimeOverlap, DEFAULT_TIME_OVERLAP, 
  219.           (double) INVALID_SET);
  220.     WRITE_LONG ("TimeSegments", TimeSegments, NOT_SET, INVALID_SET);
  221.     WRITE_LONG ("TimeSegSize", TimeSegSize, NOT_SET, INVALID_SET);
  222.     WRITE_BOOLEAN ("Topaz", Topaz, FALSE);
  223.     WRITE_WINDOWT (WindowType, RECTANGLE_WINDOW);
  224. }
  225.  
  226.